{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.Reliability Fusion Map (RFM)\n",
    "\n",
    "<br>\n",
    "\n",
    "1. `matrix` is global variable from csv file <br>\n",
    "    `f1, f2, f3...` is CNN confidence vector; <br>\n",
    "    `p` = CNN predict label; <br>\n",
    "    `y` = label of patch; <br>\n",
    "    `texture_quality` = patch texture quality factor, see formula(2) in paper\n",
    "    <hr>\n",
    "    \n",
    "2. Fusion step: `filter_texture()`->`fushion_map()`->`fusion_denisty()`; <br>\n",
    "    `filter_texture()`: filter low texture patch predictions of CNN, we set threshold_texture=0;<br>\n",
    "    `fushion_map()`: fusion step1, see formula(3) in paper; <br>\n",
    "    `fusion_denisty()`: fusion step2, see formula(4), (5) in paper; <br>\n",
    "    <hr>\n",
    "\n",
    "3. Output matrix structure is the same as input matrix <br>\n",
    "    <hr>\n",
    "    \n",
    "## 2.About \n",
    "\n",
    "This is tampering detection experiment for RFM algorithm (see experiment 1-1 in paper). <br>\n",
    "\n",
    "\n",
    "> $matrix=[f1, f2, f3, f4, f5... p, y, texture_quality]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, math, seaborn as sns, numpy as np, pandas as pd, matplotlib.pyplot as plt, matplotlib.image as mpimg\n",
    "from collections import Counter\n",
    "sns.set()\n",
    "\n",
    "# Detection for RFM algorithm, experiment 1 in paper\n",
    "# matrix=[f1, f2, f3, f4, f5, p, y, texture_quality]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "root_path = \"/data/experiment\"\n",
    "scope_name = \"pre-train_32x32\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_texture(matrix, label, threshold=0.4):\n",
    "    '''\n",
    "    Filter low texture patches\n",
    "    @matrix=[f1, f2, f3, f4, f5, p, y, texture_quality]\n",
    "    '''\n",
    "    # get placeholder\n",
    "    flag = (matrix[:, 7] < threshold)\n",
    "    matrix[flag, :5] = 0\n",
    "    matrix[flag, label] = 1\n",
    "    return matrix\n",
    "\n",
    "def fushion_map(matrix, w, h):\n",
    "    '''\n",
    "    Fusion step1: F & Q\n",
    "    After fusion，w=w-1, h=h-1, texture_quality，label=4个取投票\n",
    "    @matrix=[f1, f2, f3, f4, f5, p, y, texture_quality]\n",
    "    '''\n",
    "    matrix = np.reshape(matrix, (h, w, -1))\n",
    "    result = np.zeros((h-1, w-1, 7))\n",
    "    offset = [[0,0], [0,1], [1,0], [1,1]]\n",
    "    \n",
    "    for j in range(h - 1):\n",
    "        for i in range(w - 1):\n",
    "            # temp matrix\n",
    "            tmp_matrix = np.zeros([5])\n",
    "            total = matrix[j, i, 7] + matrix[j, i+1, 7] + matrix[j+1, i, 7] + matrix[j+1, i+1, 7]\n",
    "            for p in offset:\n",
    "                tmp_matrix += (matrix[j+p[0], i+p[1], :5]) * (matrix[j+p[0], i+p[1], 7] / total)\n",
    "            \n",
    "            # append result to F confidence\n",
    "            result[j, i, :5] = tmp_matrix\n",
    "            result[j, i, 5] = np.array(np.argmax(result[j, i, :5]), dtype=np.int32)\n",
    "            \n",
    "            label_map = []\n",
    "            for p in offset:\n",
    "                label_map.append(int(matrix[j+p[0], i+p[1], 6]))\n",
    "            result[j, i, 6] = Counter(label_map).most_common()[0][0]\n",
    "    return np.reshape(result, ((w-1) * (h-1), 7))\n",
    "\n",
    "def fusion_denisty(matrix, w, h, label, threshold=0.6):\n",
    "    '''\n",
    "    Fusion step2: R & ρ\n",
    "    @matrix=[f1, f2, f3, f4, f5, p, y, texture_quality]\n",
    "    '''\n",
    "    flag = np.where(matrix[:, 5] != label)\n",
    "    matrix = np.reshape(matrix, (h, w, -1))\n",
    "    source_matrix = matrix.copy()\n",
    "    \n",
    "    offset = [\n",
    "        [-1, -1], [-1, 0], [-1, 1], \n",
    "        [0, -1], [0, 1], \n",
    "        [1, -1], [1, 0], [1, 1]\n",
    "    ]\n",
    "    for index in list(flag[0]):\n",
    "        x = int(index % w)\n",
    "        y = int(index / w)\n",
    "        \n",
    "        length, cnt = 0, 0\n",
    "        for p in offset:\n",
    "            _x = x + p[1]\n",
    "            _y = y + p[0]\n",
    "            \n",
    "            # 检测是否在边界，如果不是边界要计算\n",
    "            if (_x >= 0) and (_y >= 0) and (_x < w) and (_y < h):\n",
    "                cnt += 1\n",
    "                # add check length+1\n",
    "                if source_matrix[_y][_x][5] != label:\n",
    "                    length += 1\n",
    "\n",
    "        # 对于周围分数过低的点，修改标签+过滤\n",
    "        if float(length / cnt) < threshold:\n",
    "            matrix[y, x, :5] = 0\n",
    "            matrix[y, x, label] = 1\n",
    "            matrix[y, x, 5] = label\n",
    "    return np.reshape(matrix, (w*h, -1))\n",
    "\n",
    "def show_map(matrix, w, h, threshold=0):\n",
    "    '''\n",
    "    Show hot map\n",
    "    @matrix=[f1, f2, f3, f4, f5, p, y]\n",
    "    '''\n",
    "    plt.clf()\n",
    "    # 计算label\n",
    "    label = np.argmax(np.bincount(np.array(matrix[:, 5], dtype=np.int32)))\n",
    "    label_list = np.ones([w*h], dtype=np.int32) * label\n",
    "    predict_list = matrix[0: w*h, 5]\n",
    "    \n",
    "    diff_matrix = np.array(np.abs(label_list - predict_list), dtype=np.bool) * 1\n",
    "    conf_matrix = np.max(matrix[:, 0:5], axis=1)\n",
    "    \n",
    "    list_matrix = np.multiply(conf_matrix, diff_matrix)\n",
    "    list_matrix[list_matrix < threshold] = 0\n",
    "    \n",
    "    xmap = np.reshape(list_matrix, (h, w))\n",
    "    return sns.heatmap(xmap, linewidths=.01, cmap='YlGnBu')\n",
    "\n",
    "score = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> start:`pre-train_32x32` path=/data/experiment/pre-train_32x32\n",
      "\n",
      "=> id=1 diff_rate=0.0187, total_diff_rate=0.0187\n",
      "=> id=2 diff_rate=0.0962, total_diff_rate=0.0574\n",
      "=> id=3 diff_rate=0.0561, total_diff_rate=0.0570\n",
      "=> id=4 diff_rate=0.0272, total_diff_rate=0.0495\n",
      "=> id=5 diff_rate=0.1061, total_diff_rate=0.0608\n",
      "=> id=6 diff_rate=0.0874, total_diff_rate=0.0653\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:28: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> id=7 diff_rate=0.0783, total_diff_rate=0.0671\n",
      "=> id=8 diff_rate=0.0085, total_diff_rate=0.0598\n",
      "=> id=9 diff_rate=0.0960, total_diff_rate=0.0638\n",
      "=> id=10 diff_rate=0.0824, total_diff_rate=0.0657\n",
      "=> id=11 diff_rate=0.0691, total_diff_rate=0.0660\n",
      "=> id=12 diff_rate=0.1997, total_diff_rate=0.0771\n",
      "=> id=13 diff_rate=0.0432, total_diff_rate=0.0745\n",
      "=> id=14 diff_rate=0.0801, total_diff_rate=0.0749\n",
      "=> id=15 diff_rate=0.0837, total_diff_rate=0.0755\n",
      "=> id=16 diff_rate=0.1891, total_diff_rate=0.0826\n",
      "=> id=17 diff_rate=0.0570, total_diff_rate=0.0811\n",
      "=> id=18 diff_rate=0.1078, total_diff_rate=0.0826\n",
      "=> id=19 diff_rate=0.1021, total_diff_rate=0.0836\n",
      "=> id=20 diff_rate=0.0843, total_diff_rate=0.0836\n",
      "=> id=21 diff_rate=0.0596, total_diff_rate=0.0825\n",
      "=> id=22 diff_rate=0.0212, total_diff_rate=0.0797\n",
      "=> id=23 diff_rate=0.0513, total_diff_rate=0.0785\n",
      "=> id=24 diff_rate=0.0384, total_diff_rate=0.0768\n",
      "=> id=25 diff_rate=0.0848, total_diff_rate=0.0771\n",
      "=> id=26 diff_rate=0.0666, total_diff_rate=0.0767\n",
      "=> id=27 diff_rate=0.0898, total_diff_rate=0.0772\n",
      "=> id=28 diff_rate=0.0310, total_diff_rate=0.0756\n",
      "=> id=29 diff_rate=0.1112, total_diff_rate=0.0768\n",
      "=> id=30 diff_rate=0.1417, total_diff_rate=0.0790\n",
      "=> id=31 diff_rate=0.0850, total_diff_rate=0.0791\n",
      "=> id=32 diff_rate=0.0594, total_diff_rate=0.0785\n",
      "=> id=33 diff_rate=0.1515, total_diff_rate=0.0807\n",
      "=> id=34 diff_rate=0.0967, total_diff_rate=0.0812\n",
      "=> id=35 diff_rate=0.0594, total_diff_rate=0.0806\n",
      "=> id=36 diff_rate=0.0105, total_diff_rate=0.0786\n",
      "=> id=37 diff_rate=0.1570, total_diff_rate=0.0808\n",
      "=> id=38 diff_rate=0.1176, total_diff_rate=0.0817\n",
      "=> id=39 diff_rate=0.1483, total_diff_rate=0.0834\n",
      "=> id=40 diff_rate=0.1200, total_diff_rate=0.0844\n",
      "=> id=41 diff_rate=0.0473, total_diff_rate=0.0834\n",
      "=> id=42 diff_rate=0.0753, total_diff_rate=0.0833\n",
      "=> id=43 diff_rate=0.0755, total_diff_rate=0.0831\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "scan all csv files, output detection result\n",
    "ctype=\"pre-train_32x32\" is forged images CNN csv output;\n",
    "ctype=\"pre-train-true_32x32\" is pristine images CNN csv output\n",
    "'''\n",
    "\n",
    "cnt1, cnt2, f_cnt1, err_cnt1, rate1, f_cnt2, err_cnt2, rate2, score1, score2 = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n",
    "ctypes = [\"pre-train_32x32\", \"pre-train-true_32x32\"]\n",
    "\n",
    "def detection(ctype, threshold=0.009, threshold_texture=0.4, threshold_density=0.6, debug=True):\n",
    "    '''\n",
    "    @return [篡改数，错判数，平均篡改率]\n",
    "    '''\n",
    "    # init variables\n",
    "    count, total_rate, error_count, forged_count, score = 0, 0, 0, 0, []\n",
    "    csv_root_path = os.path.join(root_Path, ctype)\n",
    "    \n",
    "    print(\"=> start:`{:s}` path={:s}\\n\".format(ctype, csv_root_path))\n",
    "    for name in os.listdir(csv_root_path):\n",
    "        (_w, _h) = (int(int(name.split(\"_\")[-2])), int(int(name.split(\"_\")[-1].split(\".\")[-2])))\n",
    "        (w, h) = int(_w / 32 - 1), int(_h / 32 - 1)\n",
    "\n",
    "        # @raw_data=[f1, f2, f3, f4, f5, p, y, texture]\n",
    "        raw_data = pd.read_csv(os.path.join(root_path, ctype, name)).values[:w*h, 1:9]    \n",
    "        # get_label\n",
    "        label = int(np.argmax(np.bincount(np.array(raw_data[:, 5], dtype=np.int32))))\n",
    "\n",
    "        # filter texture\n",
    "        if threshold_texture > 0:\n",
    "            texture_data = filter_texture(raw_data, label, threshold=threshold_texture)\n",
    "        else:\n",
    "            texture_data = raw_data\n",
    "        \n",
    "        # fusion step1: F & Q\n",
    "        fusion_data = fushion_map(texture_data, w, h)\n",
    "        # fusion step2: R & ρ\n",
    "        density_data = fusion_denisty(fusion_data, w-1, h-1, label, threshold=threshold_density)\n",
    "\n",
    "        # label y and predict ŷ\n",
    "        y_vector = np.ones([density_data.shape[0]], dtype=np.int32) * label\n",
    "        y_hat_vector = np.array(density_data[:, 5], dtype=np.int32)\n",
    "\n",
    "        diff_rate = 1 - np.sum(np.equal(y_vector, y_hat_vector)) / y_vector.shape[0]\n",
    "        score.append(diff_rate)\n",
    "        total_rate += diff_rate\n",
    "        \n",
    "        # final classification\n",
    "        if diff_rate > threshold:\n",
    "            # 大于阈值，判定篡改\n",
    "            forged_count += 1\n",
    "            # 对于无篡改样本，错判+1\n",
    "            if ctype == ctypes[1]:\n",
    "                error_count += 1\n",
    "        else:\n",
    "            # 对于篡改样本，错判+1\n",
    "            if ctype == ctypes[0]:\n",
    "                error_count += 1\n",
    "        count += 1   \n",
    "        if debug:\n",
    "            print(\"=> id={:d} diff_rate={:.4f}, total_diff_rate={:.4f}\".format(count, diff_rate, total_rate / count))    \n",
    "    return count, forged_count, error_count, total_rate / count, np.array(score, dtype=np.float32)\n",
    "\n",
    "# define threshold, texture, denisty\n",
    "t, t_texture, t_density = 0.009, 0.4, 0.4\n",
    "\n",
    "key = \"{0}_{1}\".format(t, t_density)\n",
    "score[key] = [0, 0]\n",
    "\n",
    "cnt1, f_cnt1, err_cnt1, rate1, score[key][0] = detection(ctypes[0], threshold=t, threshold_texture=t_texture, threshold_density=t_density, debug=True)\n",
    "cnt2, f_cnt2, err_cnt2, rate2, score[key][1] = detection(ctypes[1], threshold=t, threshold_texture=t_texture, threshold_density=t_density, debug=True)\n",
    "\n",
    "print(\"=> 篡改=({:d},{:d}) 错误=({:d},{:d}) 篡改率=({:.4f},{:.4f})\".format(\n",
    "        f_cnt1, f_cnt2, err_cnt1, err_cnt2, rate1, rate2\n",
    "    )\n",
    ")\n",
    "print(\"=> 篡改={:d} 错误={:d} 正确率={:.4f}\".format(\n",
    "        f_cnt1 + f_cnt2, err_cnt1 + err_cnt2, 1 - (err_cnt1 + err_cnt2) / 801\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['0.004_0.6', '0.009_0.6'])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/matplotlib/font_manager.py:1331: UserWarning: findfont: Font family ['Times New Roman'] not found. Falling back to DejaVu Sans\n",
      "  (prop.get_family(), self.defaultFamily[fontext]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x468 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(score.keys())\n",
    "\n",
    "from sklearn import metrics\n",
    "f, ax = plt.subplots(figsize=(12, 6.5))\n",
    "\n",
    "labels = []\n",
    "cccc = 0\n",
    "\n",
    "keys = ['0.004_0.6', '0.009_0.6']\n",
    "for key in keys:\n",
    "\n",
    "    y = list(np.append(np.ones(cnt1, dtype=np.int32) * 1, np.ones(cnt2, dtype=np.int32) * 0))\n",
    "    pred = list(np.append(score[key][0], score[key][1]))\n",
    "             \n",
    "    false_positive_rate, true_positive_rate, thresholds = metrics.roc_curve(y, pred)\n",
    "    roc_auc = metrics.auc(false_positive_rate, true_positive_rate)\n",
    "\n",
    "    plt.plot(false_positive_rate, true_positive_rate, linewidth=3.0)\n",
    "    labels.append('AUC={:.3f} (γ1={:.1f}, γ2={:.3f})'.format(roc_auc, float(key.split(\"_\")[1]), float(key.split(\"_\")[0])))\n",
    "                \n",
    "font = {'family': 'Times New Roman', 'weight': 'normal', 'size': 18}\n",
    "legend = plt.legend(labels, prop=font)\n",
    "\n",
    "plt.plot([0,1],[0,1],'r--')\n",
    "plt.xticks(np.arange(0, 1.1, 0.1), fontsize=18)\n",
    "plt.yticks(np.arange(0, 1.1, 0.1), fontsize=18)\n",
    "\n",
    "plt.ylabel('True Positive Rate', fontsize=24)\n",
    "plt.xlabel('False Positive Rate', fontsize=24)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# saving experiment pdf\n",
    "f.savefig(\"experiment1_1.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
